package www.com.library.util;

import java.math.BigDecimal;
import java.text.DecimalFormat;

/**
 * double类型价格格式规范类
 *
 * @author Administrator
 */
public class DoubleConverter {
    private static final DecimalFormat mDF10 = new DecimalFormat("#.##########");
    public static final double RELATIVE_SMALL_DOUBLE_VALUE = 0.0000000001d;

    /*
     *默认格式
     */
    public static double normalize(double value) {
        try {
            return Double.valueOf(mDF10.format(value));
        } catch (NumberFormatException e) {
            return value;
        }
    }

    /*
     *默认格式
     */
    public static float normalize(float value) {
        try {
            return Float.valueOf(mDF10.format(value));
        } catch (NumberFormatException e) {
            return value;
        }
    }

    /*
     *判断是否为0
     */
    public static boolean isZero(double value) {
        return (value < RELATIVE_SMALL_DOUBLE_VALUE && value > -RELATIVE_SMALL_DOUBLE_VALUE);
    }

    /**
     * 比较大小，是否大于0
     *
     * @param value
     * @return
     */
    public static boolean isGTZero(double value) {
        return (value > RELATIVE_SMALL_DOUBLE_VALUE);
    }

    /**
     * 比较大小，是否小于0
     *
     * @param value
     * @return
     */
    public static boolean isLTZero(double value) {
        return (value < -RELATIVE_SMALL_DOUBLE_VALUE);
    }

    /**
     * 比较大小，v1是否大于v2
     *
     * @param v1
     * @param v2
     * @param digits 小数位数
     * @return
     */
    public static boolean isGT(double v1, double v2, int digits) {
        final double power = Math.pow(10, digits);
        final long v1L = Math.round(v1 * power);
        final long v2L = Math.round(v2 * power);
        return (v1L > v2L);
    }

    /**
     * 比较大小，v1是否小于v2
     *
     * @param v1
     * @param v2
     * @param digits 小数位数
     * @return
     */
    public static boolean isLT(double v1, double v2, int digits) {
        final double power = Math.pow(10, digits);
        final long v1L = Math.round(v1 * power);
        final long v2L = Math.round(v2 * power);
        return (v1L < v2L);
    }

    /**
     * 比较大小，v1是否等于v2
     *
     * @param v1
     * @param v2
     * @param digits 小数位数
     * @return
     */
    public static boolean isEqual(double v1, double v2, int digits) {
        final double power = Math.pow(10, digits);
        final long v1L = Math.round(v1 * power);
        final long v2L = Math.round(v2 * power);
        return (v1L == v2L);
    }

    /**
     * 价格格式转换,将float转换成string
     */
    public static String toStringData(float data) {
        return String.valueOf(data);
    }

    /**
     * 价格格式转换，double转成string
     */
    public static String toStringData(double data) {
        return String.valueOf(data);
    }

    /**
     * 价格格式转换，int
     */
    public static String toStringData(int data) {
        return String.valueOf(data);
    }

    /**
     * 价格格式转换，digit位小数
     */
    public static String toStringData(float data, int digit) {
        String formatter = "%1$." + digit + "f";
        return String.format(formatter, data);
    }

    /**
     * 价格格式转换，digit位小数
     */
    public static String toStringData(double data, int digit) {
        String formatter = "%1$." + digit + "f";
        return String.format(formatter, data);
    }

    /**
     * 价格格式转换，digit位小数
     */
    public static String toStringData(String data, int digit) {
        return toStringData(toDoubleData(data), digit);
    }

    /**
     * 将字符串转换成int类型数字
     *
     * @param data
     * @return
     */
    public static int toIntData(String data) {
        if (null != data && data.length() > 0) {
            boolean isNum = data.contains("-") ? data.matches("^(-)[0-9]+") : data.matches("[0-9]+");
            if (isNum) {
                return Integer.valueOf(data);
            }
        }
        return 0;
    }

    /**
     * 将字符串转换成long类型数字
     *
     * @param data
     * @return
     */
    public static long toLongData(String data) {
        if (null != data && data.length() > 0) {
            boolean isNum = data.contains("-") ? data.matches("^(-)[0-9]+") : data.matches("[0-9]+");
            if (isNum) {
                return Long.parseLong(data);
            }
        }
        return 0;
    }

    /**
     * 将字符串转换成float类型数字
     *
     * @param data
     * @return
     */
    public static float toFloatData(String data) {
        if (null != data && data.length() > 0) {
            if (data.contains("+")) {
                data = data.substring(1, data.length());
            }
            boolean isNum = data.contains("-") ? data.matches("^(-)[0-9]*\\.[0-9]*") : data.matches("[0-9]*\\.[0-9]*");
            if (isNum) {
                if (data.length() > 1) {
                    return Float.valueOf(data);
                }
                return 0.0f;
            } else {
                return toIntData(data);
            }
        }
        return 0.0f;
    }

    /**
     * 将字符串转换成int类型数字
     *
     * @param data
     * @return
     */
    public static double toDoubleData(String data) {
        if (null != data && data.length() > 0) {
            boolean isNum = data.contains("-") ? data.matches("^(-)[0-9]*\\.[0-9]*") : data.matches("[0-9]*\\.[0-9]*");
            if (isNum) {
                if (data.length() > 1) {
                    return Double.valueOf(data);
                }
                return 0.0f;
            } else {
                return toIntData(data);
            }
        }
        return 0.00;
    }

    /**
     * 根据小数位转换float数据
     *
     * @param data
     * @param digit
     * @return
     */
    public static float toFloat(int digit, float data) {
        String formatter = "%1$." + digit + "f";
        String str = String.format(formatter, data);
        return Float.valueOf(str);
    }


    /**
     * 根据小数位转换double数据
     *
     * @param data
     * @param digit
     * @return
     */
    public static double toDouble(int digit, double data) {
        String formatter = "%1$." + digit + "f";
        String str = String.format(formatter, data);
        return Double.valueOf(str);
    }

    /**
     * 浮点类型保留小数位(与pc算法一致)
     *
     * @param dbold
     * @param nPow
     * @return
     */
    public static double RoundResult(double dbold, int nPow) {
        if (isZero(dbold)) {
            return 0.0;
        }
        float fBase = 10.0f;
        double dbadd;
        if (dbold > 0.0) {
            dbadd = 0.501;
        } else {
            dbadd = -0.501;
        }
        int i = (int) (dbold * Math.pow(fBase, nPow) + dbadd);
        return (double) (i / Math.pow(fBase, nPow));
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static float add(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.add(b2).floatValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static float sub(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.subtract(b2).floatValue();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */

    public static float mul(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.multiply(b2).floatValue();
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */

    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 价格格式转换，主要用于伦敦银的点差，若小数位为00显示整数，若小数位不为0（1-9）等则显示两位小数，若小数位为（1-9）0等则显示一位小数
     */
    public static String toZeroOr2Decimal(double data) {
        if (DoubleConverter.isZero(data))
            return "0";

        final double absData = Math.abs(data) + 0.0001d;
        final String formatStr = (data < 0) ? "-%1$.2f" : "%1$.2f";
        String str = String.format(formatStr, absData);
        if (str.endsWith(".00")) {
            return toDecimal(data);
        } else if (str.endsWith(".10") || str.endsWith(".20") || str.endsWith(".30")
                || str.endsWith(".40") || str.endsWith(".50") || str.endsWith(".60")
                || str.endsWith(".70") || str.endsWith(".80") || str.endsWith(".90")) {
            return to1Decimal(data);
        }
        return str;
    }

    /**
     * 价格格式转换
     */
    public static String toDecimal(double data) {
        if (DoubleConverter.isZero(data))
            return "0";

        final double absData = Math.abs(data) + 0.01d;
        if (data < 0)
            return "-" + String.valueOf(Math.round(absData));
        else
            return String.valueOf(Math.round(absData));
    }

    /**
     * 若小数位不为0则显示一位小数
     */
    public static String to1Decimal(double data) {
        if (DoubleConverter.isZero(data))
            return "0.0";

        final double absData = Math.abs(data) + 0.0001d;
        final String formatStr = (data < 0) ? "-%1$.1f" : "%1$.1f";
        String str = String.format(formatStr, absData);
        return str;
    }

    /**
     * 若小数位不为0则显示一位小数
     */
    public static String to2Decimal(double data) {
        if (DoubleConverter.isZero(data))
            return "0.00";

        final double absData = Math.abs(data) + 0.0001d;
        final String formatStr = (data < 0) ? "-%1$.2f" : "%1$.2f";
        String str = String.format(formatStr, absData);
        return str;
    }

    /**
     * 若小数位不为0则显示一位小数
     */
    public static String to2Decimal$(double data) {
        if (DoubleConverter.isZero(data))
            return "$0.00";
        final double absData = Math.abs(data) + 0.0001d;
        final String formatStr = (data < 0) ? "-$%1.2f" : "$%1.2f";
        return String.format(formatStr, absData);
    }

    /**
     * 相加的结果是否大于0
     */
    public static int addResult(double result) {
        if (result > 0) {
            return 1;
        } else if (result < 0) {
            return -1;
        } else {
            return 0;
        }
    }


}
